\documentclass{article}

\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
\usepackage[francais]{babel}

\begin{document}
\section*{Langage de description de netlist}
\subsection*{Structure d'un fichier de description}
Le fichier est composé d'une suite de déclaration de \emph{blocs}.

\begin{verbatim}
nomBloc (a,b,c,...) = (d,e,f,...)
{
     description du bloc...
}

\end{verbatim}

où a,b,c sont les variables d'entrée, et d,e,f sont les variables de sorties. Un bloc peut en utiliser un autre, sans inquiétude sur la position relative des définitions.

\subsection*{Description d'un bloc}

L'intérieur du bloc se compose d'une suite d'affectations (éventuellement une liste de variables), utilisant les primitives and, not, or, xor,reg des blocs définis dans le fichier. Une affectation correspond au lien entre 2 fils du circuit. a=b signifie une soudure, b=not(a) signifie qu'il y a un opérateur not entre a et b.
\begin{verbatim}
blocA (a,b,c) = (d,e,f)
{
     d = and( a , b )
     e = xor( or( a , b ) , c )
     f = reg( e ) 
}

 blocB (a,b) = (d,e,f,g)
{
     ( d , e , f , g ) = ( blocA ( a , b , not ( and ( a , b ) ) ) , and ( a , b ) )
}

\end{verbatim}

On peut utiliser une variable avant de la déclarer. Attention cependant, l'utilisation de variables non déclarées n'est pas détecté par le compilateur. On autorise des commentaires mono-lignes, indiqués par le symbole $//$.

\subsection*{Gros fils}
Une variable dont le nom commence par un entier représente un gros fil. Ainsi, $32fil$ représente 32 fils. On peut accéder au fil numéro $i$ par la syntaxe $32fil[i]$.\\
Il est important de savoir que $2fil$ est remplacé à la lecture du document par $2fil[0],2fil[1]$, ce qui explique la nécessitée de la syntaxe : $(32fil) = zero32()$. Sans les parenthèses autour de $32fil$, on obtient une erreur de grammaire.\\

\subsection*{Boucle For}
Pour bien exploiter les gros fils, il est intéressant d'utiliser des boucles for. Leur syntaxe est la suivante :
\begin{verbatim}
// on fait varier i de 0 à 31
for(i,0,31){
    32out[i]=33in[i+1]
}
\end{verbatim}
Les opérations arithmétiques $+$ et $-$ dans les crochets ne sont utilisables qu'à l'intèrieur d'une boucle for et ne sont utilisables que sur des constantes et le compteur de boucle. Les boucles for ne peuvent pas être imbriquées.

\subsection*{Include}
Il est possible, d'inclure un fichier .dr dans un autre. Une inclusion se comporte comme si le contenu du fichier inclus était recopié. Les directives d'inclusion se trouvent forcément en premières lignes, et suivent la syntaxe : 
\begin{verbatim}
#include fichier.dr
\end{verbatim}

\subsection*{Affichage}
A la fin du main, on peut rajouter trois lignes, dans cet ordre :
\begin{verbatim}
//Permet au simulateur de suivre les valeurs de ces variables
//Il est nécessaire de mettre les entrees du main dans le print
print(a,b,32c)

//Ajoute le suivi des adresses de la RAM ou de la ROM dans le simulateur
printAddrRam(21,42,84)
printAddrRom(21,42,84)
\end{verbatim}

\subsection*{Fichier .in}
Pour pouvoir tester des circuits, il est parfois souhaitables d'avoir une entree de bloc main variable. C'est possible par le biais des fichiers .in. Supposons que notre fichier .dr soit :

\begin{verbatim}
main(2a)=(b){
    b=and(2a[0],2a[1])
    print(2a,b)
}
\end{verbatim}

On veut créer un fichier .in exploitable par le simulateur. En voilà un exemple : 

\begin{verbatim}
2 5
2a[0] 0 0 1 0 1 
2a[1] 1 0 0 1 1
\end{verbatim}

Le premier entier est le nombre de variables d'entrée. Le second, le nombre de valeurs qu'elles vont prendres.

\end{document}
